package main

//
//type item struct {
//	index int
//	num   int
//}
//
//type priorityQueue []item
//
//func (pq priorityQueue) Len() int {
//	return len(pq)
//}
//
//func (pq priorityQueue) Less(i, j int) bool {
//	return pq[i].num > pq[j].num
//}
//
//func (pq priorityQueue) Swap(i, j int) {
//	pq[i], pq[j] = pq[j], pq[i]
//}
//
//func (pq *priorityQueue) Push(val any) {
//	(*pq) = append(*pq, val.(item))
//}
//
//func (pq *priorityQueue) Pop() (val any) {
//	fmt.Println("POP: ", pq)
//	val = (*pq)[len(*pq)-1]
//	(*pq) = (*pq)[:len(*pq)-1]
//	return
//}
//
//func (pq priorityQueue) Top() any {
//	return pq[0]
//}
//
//func maxSlidingWindow(nums []int, k int) []int {
//	res := make([]int, 0)
//	hp := make(priorityQueue, 0)
//	pq := &hp
//	heap.Init(pq)
//	for i := 0; i < k; i++ {
//		heap.Push(pq, item{i, nums[i]})
//	}
//	fmt.Println(pq)
//	fmt.Println(heap.Pop(pq))
//
//	//res = append(res, pq.Top().(item).num)
//	//for i := k; i < len(nums); i++ {
//	//	heap.Push(pq, item{i, nums[i]})
//	//	for pq.Top().(item).index < i-k+1 {
//	//		heap.Pop(pq)
//	//	}
//	//	res = append(res, hp.Top().(item).num)
//	//}
//	return res
//}
//
//func main() {
//	fmt.Println(maxSlidingWindow([]int{1, 3, -1, -3, 5, 3, 6, 7}, 3))
//}

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
//
//type ListNode struct {
//	Val  int
//	Next *ListNode
//}
//
//type priorityQueue []*ListNode
//
//func (pq priorityQueue) Len() int {
//	return len(pq)
//}
//
//func (pq priorityQueue) Swap(i, j int) {
//	pq[i], pq[j] = pq[j], pq[i]
//}
//
//func (pq priorityQueue) Less(i, j int) bool {
//	return pq[i].Val < pq[j].Val
//}
//
//func (pq *priorityQueue) Push(Val any) {
//	*pq = append(*pq, Val.(*ListNode))
//}
//
//func (pq *priorityQueue) Pop() (Val any) {
//	Val = (*pq)[len(*pq)-1]
//	(*pq) = (*pq)[0 : len(*pq)-1]
//	return
//}
//
//func mergeKLists(lists []*ListNode) *ListNode {
//	var pq priorityQueue
//	pq = lists
//	heap.Init(&pq)
//	fmt.Println(pq)
//
//	return nil
//}

//type node struct {
//	key        int
//	val        int
//	prev, next *node
//}
//
//type LRUCache struct {
//	cap, size  int
//	head, tail *node
//	cache      map[int]*node
//}
//
//func Constructor(capacity int) LRUCache {
//	var cache LRUCache
//
//	cache.cap = capacity
//	cache.size = 0
//	cache.head = &node{0, 0, nil, nil}
//	cache.tail = &node{0, 0, nil, nil}
//	cache.head.next = cache.tail
//	cache.tail.prev = cache.head
//	cache.cache = make(map[int]*node)
//
//	return cache
//}
//
//func (this *LRUCache) Get(key int) int {
//	if node, ok := this.cache[key]; ok {
//		moveHead(this, node)
//		return node.val
//	} else {
//		return -1
//	}
//}
//
//func (this *LRUCache) Put(key int, value int) {
//	if node, ok := this.cache[key]; ok {
//		moveHead(this, node)
//		node.val = value
//	} else {
//		if this.size == this.cap {
//			removeTail(this)
//			this.size--
//		}
//		insertHead(this, key, value)
//		this.size++
//	}
//}
//
//func moveHead(cache *LRUCache, node *node) {
//	prev := node.prev
//	next := node.next
//
//	prev.next = next
//	next.prev = prev
//
//	headNext := cache.head.next
//	node.next = headNext
//	headNext.prev = node
//	node.prev = cache.head
//	cache.head.next = node
//
//	cache.cache[node.key] = cache.head.next
//}
//
//func removeTail(cache *LRUCache) {
//	node := cache.tail.prev
//	delete(cache.cache, node.key)
//	prevnode := node.prev
//	prevnode.next = cache.tail
//	cache.tail.prev = prevnode
//}
//
//func insertHead(cache *LRUCache, key, val int) {
//	node := &node{key, val, nil, nil}
//
//	headNext := cache.head.next
//	node.next = headNext
//	headNext.prev = node
//	node.prev = cache.head
//	cache.head.next = node
//
//	cache.cache[key] = cache.head.next
//}

//func main() {
//	var str string
//	str = "hello world"
//	fmt.Println(str)
//	strByte := []byte(str)
//	strByte[0] = 'e'
//	str = string(strByte)
//	fmt.Println(str)
//	str = strings.Replace(str, "world", "myworld", 1)
//	fmt.Println(str)
//}

// 闭包运用：保存中间态
//func test1() func() int {
//	num := 0
//	return func() int {
//		num++
//		return num
//	}
//}
//
//func main() {
//	fun := test1()
//	fmt.Println(fun())
//	fmt.Println(fun())
//	fmt.Println(fun())
//	fmt.Println(fun())
//	fmt.Println(fun())
//}

// 闭包运用：函数工厂
//func factory(str string) func(a, b int) int {
//	switch str {
//	case "add":
//		return func(a, b int) int {
//			return a + b
//		}
//	case "sub":
//		return func(a, b int) int {
//			return a - b
//		}
//	case "mul":
//		return func(a, b int) int {
//			return a * b
//		}
//	case "div":
//		return func(a, b int) int {
//			return a / b
//		}
//	default:
//		return func(a, b int) int {
//			fmt.Println("unknown message")
//			return 0
//		}
//	}
//}
//
//func main() {
//	add := factory("add")
//	fmt.Println(add(1, 2))
//	sub := factory("sub")
//	fmt.Println(sub(1, 2))
//	de := factory("de")
//	fmt.Println(de(1, 2))
//}

// 装饰器模式
//func test(fn func(int) int) func(int) int {
//	return func(x int) int {
//		result := fn(x)
//		fmt.Println(result * 2)
//		return result
//	}
//}
//
//func square(x int) int {
//	return x * x
//}
//
//func main() {
//	fn := test(square)
//	fmt.Println(fn(3))
//}

//func task(input int, callback func(int)) {
//	go func() {
//		time.Sleep(1 * time.Second)
//		input = input * 3
//		callback(input)
//	}()
//}
//
//// 回调函数
//func main() {
//	callback := func(input int) {
//		fmt.Println(input)
//	}
//	task(3, callback)
//	time.Sleep(5 * time.Second)
//}

//func main() {
//	var wg sync.WaitGroup
//	strs := []string{"hello", "world", "this"}
//	for i := 0; i < len(strs); i++ {
//		wg.Add(1)
//		go func(str string) {
//			defer wg.Done()
//			fmt.Println(str)
//		}(strs[i])
//	}
//	wg.Wait()
//}

// 1. 中间态
// 2. 工厂函数
// 3. 装饰器
// 4. 回调函数
// 5. 并发

//func div(a, b int) (res int, err error) {
//	defer func() {
//		if r := recover(); r != nil {
//			err = fmt.Errorf("error: %v", r)
//		}
//	}()
//	return a / b, nil
//}
//
//func main() {
//	res, _ := div(10, 0)
//	fmt.Println(res)
//	fmt.Println(div(10, 2))
//	fmt.Println(div(10, 0))
//	fmt.Println(div(10, 2))
//}

//func main() {
//	var num1 int8
//	num1 = 10
//	fmt.Println(num1)
//
//	//var num interface{}
//	//num = 1
//	//fmt.Println(num.(int8))
//	//fmt.Println(num.(int16))
//}

//func test() {
//	defer func() {
//		if r := recover(); r != nil {
//			fmt.Println("error is:", r)
//		}
//	}()
//	panic("hello world")
//}
//
//func main() {
//	test()
//}

//func main() {
//	path := []int{1, 2, 3}
//	var res [][]int
//	res = append(res, path)
//	fmt.Println("res", res)
//	fmt.Println("path", path)
//
//	path[0] = 10
//	fmt.Println("res", res)
//	fmt.Println("path", path)
//
//	path = append(path, 1000)
//	path[0] = 20
//	fmt.Println("res", res)
//	fmt.Println("path", path)
//}

//func main() {
//	nums := []int{1, 2, 3, 4}
//	newNums := nums[1:4]
//	fmt.Println(newNums)
//	nums[1] = 20
//	fmt.Println(newNums)
//	newNums = append(newNums, 1000)
//	nums[1] = 200
//	fmt.Println(newNums)
//}

//func test(nums []int) {
//	nums[1] = 10
//}
//
//func test2(nums [5]int) {
//	nums[1] = 10
//}
//
//func main() {
//	nums := []int{1, 2, 3}
//	fmt.Println(nums)
//	test(nums)
//	fmt.Println(nums)
//
//	nums2 := [5]int{1, 2, 3}
//	fmt.Println(nums2)
//	test2(nums2)
//	fmt.Println(nums2)
//}

//type person struct {
//	name string
//	age  int
//}
//
//func (p person) func1() {
//	p.name = "func1"
//}
//
//func (p *person) func2() {
//	p.name = "func2"
//}
//
//func main() {
//	p1 := person{age: 10, name: "test"}
//	fmt.Println(p1)
//	p1.func1()
//	fmt.Println(p1)
//	p1.func2()
//	fmt.Println(p1)
//}

//func getSlicePointer() *[]int {
//	slice := []int{1, 2, 3}
//	return &slice
//}
//
//func main() {
//	slicePtr := getSlicePointer()
//	slice := *slicePtr
//	fmt.Printf("初始容量: %d\n", cap(slice)) // 输出初始容量
//
//	// 进行扩容操作
//	for i := 4; i <= 10; i++ {
//		slice = append(slice, i)
//	}
//	fmt.Printf("扩容后容量: %d\n", cap(slice)) // 输出扩容后的容量
//
//	// 再次使用原指针可能会出现问题
//	// 由于底层数组已改变，原指针指向的可能是旧的、无效的数据
//	fmt.Println(*slicePtr)
//	fmt.Println(slice)
//}

//type person struct {
//	name string
//}
//
//func (p *person) test() {
//	fmt.Println("hello")
//}
//
//func main() {
//	p := &person{name: "hello"}
//	p.name = "alice"
//	p.test()
//
//	var p2 *person = nil
//	p2.test()
//}

//func test(args ...int) int {
//	sum := 0
//	for i := 0; i < len(args); i++ {
//		sum += args[i]
//	}
//	return sum
//}

//func main() {
//	fmt.Println(test())
//	fmt.Println(test(0))
//	fmt.Println(test(1))
//	fmt.Println(test(1, 2, 3, 4))
//	fmt.Println(test(1, 1, 1, 1, 1, 1, 1))
//	fmt.Println(test(2, 2, 2))
//	fmt.Println(test(1111, 111))
//}

//type person struct {
//	name    string
//	address string
//	age     int
//}
//
//type option func(*person)
//
//func setName(name string) option {
//	return func(p *person) {
//		p.name = name
//	}
//}
//
//func setAddress(address string) option {
//	return func(p *person) {
//		p.address = address
//	}
//}
//
//func setAge(age int) option {
//	return func(p *person) {
//		p.age = age
//	}
//}
//
//func newUser(op ...option) *person {
//	p := &person{address: "default_address", name: "default_name", age: 0}
//
//	for i := 0; i < len(op); i++ {
//		op[i](p)
//	}
//
//	return p
//}
//
//func main() {
//	p := newUser(setAddress("beijing"), setAge(20))
//	fmt.Println(p)
//}

//func main() {
//	a := 0
//	a = 10
//	defer fmt.Println(a)
//}

//type person struct {
//	Name string      `json:"name"`
//	Age  int         `json:"age,string"`
//	Data interface{} `json:"data,string"`
//}
//
//func main() {
//	msg := map[string]interface{}{
//		"hello": "world",
//		"job":   "worker",
//		"num":   1,
//	}
//	msg["hello1"] = "world1"
//	p := person{Name: "job", Age: 10, Data: msg}
//	jsondata, _ := json.Marshal(p)
//	fmt.Println(string(jsondata))
//}

//func test() {
//	done := make(chan struct{})
//	go func() {
//		fmt.Println("准备休眠...")
//		time.Sleep(3 * time.Second)
//		done <- struct{}{}
//		fmt.Println("结束")
//	}()
//	fmt.Println("等待routine")
//	<-done
//	fmt.Println("done")
//}
//
//func main() {
//	test()
//}

//func main() {
//	var str = "hello world"
//	bytes := []byte(str)
//	bytes[0] = 'a'
//	str = string(bytes)
//	fmt.Println(str)
//}

//func main() {
//	str := "hello world"
//	byteArray := *(*[]byte)(unsafe.Pointer(&str))
//	fmt.Printf("%s", byteArray)
//}

//func main() {
//	str := "我的世界2121aaa"
//	runeArray := []rune(str)
//	for i := 0; i < len(runeArray)/2; i++ {
//		runeArray[i], runeArray[len(runeArray)-1-i] = runeArray[len(runeArray)-1-i], runeArray[i]
//	}
//	str = string(runeArray)
//	fmt.Println(str)
//}

//func isSorted[T any](nums []T, cmp func(a, b T) bool) bool {
//	for i := 1; i < len(nums); i++ {
//		if cmp(nums[i-1], nums[i]) {
//			return false
//		}
//	}
//	return true
//}
//
//func cmp(a, b int) bool {
//	return a > b
//}

//func main() {
//	nums := []int{1, 2, 3, 5, 4}
//	nums1 := []int{1, 2, 3, 4}
//	fmt.Println(isSorted(nums, cmp))
//	fmt.Println(isSorted(nums1, cmp))
//}

//func sort(array *[]int, l, r int) {
//	nums := *array
//	if l > r {
//		return
//	}
//	key := nums[l]
//	left, right, i := l-1, r+1, l
//	for i < right {
//		if nums[i] < key {
//			left++
//			nums[left], nums[i] = nums[i], nums[left]
//			i++
//		} else if nums[i] > key {
//			right--
//			nums[right], nums[i] = nums[i], nums[right]
//		} else {
//			i++
//		}
//	}
//	// [l left] [right r]
//	sort(array, l, left)
//	sort(array, right, r)
//}

//func sort(array *[]int, l, r int) {
//	nums := *array
//	if l >= r {
//		return
//	}
//	mid := l + (r-l)/2
//	sort(array, l, mid)
//	sort(array, mid+1, r)
//	cur1, cur2, i := l, mid+1, 0
//	tmp := make([]int, len(nums))
//	for cur1 <= mid && cur2 <= r {
//		if nums[cur1] < nums[cur2] {
//			tmp[i] = nums[cur1]
//			cur1++
//		} else {
//			tmp[i] = nums[cur2]
//			cur2++
//		}
//		i++
//	}
//	for cur1 <= mid {
//		tmp[i] = nums[cur1]
//		cur1++
//		i++
//	}
//	for cur2 <= r {
//		tmp[i] = nums[cur2]
//		cur2++
//		i++
//	}
//	for i := l; i <= r; i++ {
//		nums[i] = tmp[i-l]
//	}
//}
//
//func main() {
//	nums := []int{1, 2, 5555, 22, 11, 222222}
//	sort(&nums, 0, len(nums)-1)
//	fmt.Println(nums)
//}

//type person struct {
//	Name float64
//	Age  int64
//}
//
//func personToBinary(nums []person) ([]byte, error) {
//	buf := new(bytes.Buffer)
//	for i := 0; i < len(nums); i++ {
//		if err := binary.Write(buf, binary.LittleEndian, nums[i]); err != nil {
//			return nil, err
//		}
//	}
//	return buf.Bytes(), nil
//}
//
//func binaryToPerson(data []byte) ([]person, error) {
//	var res []person
//	buf := bytes.NewReader(data)
//	for buf.Len() > 0 {
//		var tmp person
//		if err := binary.Read(buf, binary.LittleEndian, &tmp); err != nil {
//			return nil, err
//		}
//		res = append(res, tmp)
//	}
//	return res, nil
//}
//
//func main() {
//	p := []person{{Name: 1.23, Age: 20}}
//	bin, err := personToBinary(p)
//	if err != nil {
//		fmt.Println(err)
//	}
//	newp, err := binaryToPerson(bin)
//	if err != nil {
//		fmt.Println(err)
//	}
//	fmt.Println(newp)
//}

//func main() {
//	nums := []int{1, 2, 3}
//	for i := range nums {
//		fmt.Println(i)
//	}
//}

// 交替打印AB
//func main() {
//	ch1 := make(chan struct{})
//	ch2 := make(chan struct{})
//	ch3 := make(chan struct{})
//
//	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
//	defer cancel()
//
//	var wg sync.WaitGroup
//	wg.Add(1)
//	go func() {
//		defer wg.Done()
//		for {
//			select {
//			case <-ch1:
//				print("A")
//				time.Sleep(time.Second / 2)
//				select {
//				case ch2 <- struct{}{}:
//				case <-ctx.Done():
//					return
//				}
//			case <-ctx.Done():
//				return
//			}
//		}
//	}()
//
//	wg.Add(1)
//	go func() {
//		defer wg.Done()
//		for {
//			select {
//			case <-ch2:
//				print("B")
//				time.Sleep(time.Second / 2)
//				select {
//				case ch3 <- struct{}{}:
//				case <-ctx.Done():
//					return
//				}
//			case <-ctx.Done():
//				return
//			}
//		}
//	}()
//
//	wg.Add(1)
//	go func() {
//		defer wg.Done()
//		for {
//			select {
//			case <-ch3:
//				print("C")
//				time.Sleep(time.Second / 2)
//				select {
//				case ch1 <- struct{}{}:
//				case <-ctx.Done():
//					return
//				}
//			case <-ctx.Done():
//				return
//			}
//		}
//	}()
//
//	ch1 <- struct{}{}
//
//	wg.Wait()
//}

func main() {

}
